home *** CD-ROM | disk | FTP | other *** search
/ Aminet 51 / Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso / Aminet / dev / gg / openssl-bin.lha / ssl / include / openssl / crypto.h < prev    next >
Encoding:
C/C++ Source or Header  |  2002-08-08  |  15.2 KB  |  405 lines
  1. /* crypto/crypto.h */
  2. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  3.  * All rights reserved.
  4.  *
  5.  * This package is an SSL implementation written
  6.  * by Eric Young (eay@cryptsoft.com).
  7.  * The implementation was written so as to conform with Netscapes SSL.
  8.  * 
  9.  * This library is free for commercial and non-commercial use as long as
  10.  * the following conditions are aheared to.  The following conditions
  11.  * apply to all code found in this distribution, be it the RC4, RSA,
  12.  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13.  * included with this distribution is covered by the same copyright terms
  14.  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15.  * 
  16.  * Copyright remains Eric Young's, and as such any Copyright notices in
  17.  * the code are not to be removed.
  18.  * If this package is used in a product, Eric Young should be given attribution
  19.  * as the author of the parts of the library used.
  20.  * This can be in the form of a textual message at program startup or
  21.  * in documentation (online or textual) provided with the package.
  22.  * 
  23.  * Redistribution and use in source and binary forms, with or without
  24.  * modification, are permitted provided that the following conditions
  25.  * are met:
  26.  * 1. Redistributions of source code must retain the copyright
  27.  *    notice, this list of conditions and the following disclaimer.
  28.  * 2. Redistributions in binary form must reproduce the above copyright
  29.  *    notice, this list of conditions and the following disclaimer in the
  30.  *    documentation and/or other materials provided with the distribution.
  31.  * 3. All advertising materials mentioning features or use of this software
  32.  *    must display the following acknowledgement:
  33.  *    "This product includes cryptographic software written by
  34.  *     Eric Young (eay@cryptsoft.com)"
  35.  *    The word 'cryptographic' can be left out if the rouines from the library
  36.  *    being used are not cryptographic related :-).
  37.  * 4. If you include any Windows specific code (or a derivative thereof) from 
  38.  *    the apps directory (application code) you must include an acknowledgement:
  39.  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40.  * 
  41.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51.  * SUCH DAMAGE.
  52.  * 
  53.  * The licence and distribution terms for any publically available version or
  54.  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55.  * copied and put under another distribution licence
  56.  * [including the GNU Public Licence.]
  57.  */
  58.  
  59. #ifndef HEADER_CRYPTO_H
  60. #define HEADER_CRYPTO_H
  61.  
  62. #include <stdlib.h>
  63.  
  64. #ifndef NO_FP_API
  65. #include <stdio.h>
  66. #endif
  67.  
  68. #include <openssl/stack.h>
  69. #include <openssl/safestack.h>
  70. #include <openssl/opensslv.h>
  71.  
  72. #ifdef CHARSET_EBCDIC
  73. #include <openssl/ebcdic.h>
  74. #endif
  75.  
  76. /* Resolve problems on some operating systems with symbol names that clash
  77.    one way or another */
  78. #include <openssl/symhacks.h>
  79.  
  80. #ifdef  __cplusplus
  81. extern "C" {
  82. #endif
  83.  
  84. /* Backward compatibility to SSLeay */
  85. /* This is more to be used to check the correct DLL is being used
  86.  * in the MS world. */
  87. #define SSLEAY_VERSION_NUMBER    OPENSSL_VERSION_NUMBER
  88. #define SSLEAY_VERSION        0
  89. /* #define SSLEAY_OPTIONS    1 no longer supported */
  90. #define SSLEAY_CFLAGS        2
  91. #define SSLEAY_BUILT_ON        3
  92. #define SSLEAY_PLATFORM        4
  93.  
  94. /* When changing the CRYPTO_LOCK_* list, be sure to maintin the text lock
  95.  * names in cryptlib.c
  96.  */
  97.  
  98. #define    CRYPTO_LOCK_ERR            1
  99. #define    CRYPTO_LOCK_ERR_HASH        2
  100. #define    CRYPTO_LOCK_X509        3
  101. #define    CRYPTO_LOCK_X509_INFO        4
  102. #define    CRYPTO_LOCK_X509_PKEY        5
  103. #define CRYPTO_LOCK_X509_CRL        6
  104. #define CRYPTO_LOCK_X509_REQ        7
  105. #define CRYPTO_LOCK_DSA            8
  106. #define CRYPTO_LOCK_RSA            9
  107. #define CRYPTO_LOCK_EVP_PKEY        10
  108. #define    CRYPTO_LOCK_X509_STORE        11
  109. #define    CRYPTO_LOCK_SSL_CTX        12
  110. #define    CRYPTO_LOCK_SSL_CERT        13
  111. #define    CRYPTO_LOCK_SSL_SESSION        14
  112. #define    CRYPTO_LOCK_SSL_SESS_CERT    15
  113. #define    CRYPTO_LOCK_SSL            16
  114. #define    CRYPTO_LOCK_RAND        17
  115. #define    CRYPTO_LOCK_RAND2        18
  116. #define    CRYPTO_LOCK_MALLOC        19
  117. #define    CRYPTO_LOCK_BIO            20
  118. #define    CRYPTO_LOCK_GETHOSTBYNAME    21
  119. #define    CRYPTO_LOCK_GETSERVBYNAME    22
  120. #define    CRYPTO_LOCK_READDIR        23
  121. #define    CRYPTO_LOCK_RSA_BLINDING    24
  122. #define    CRYPTO_LOCK_DH            25
  123. #define    CRYPTO_LOCK_MALLOC2        26
  124. #define    CRYPTO_LOCK_DSO            27
  125. #define    CRYPTO_LOCK_DYNLOCK        28
  126. #define    CRYPTO_NUM_LOCKS        29
  127.  
  128. #define CRYPTO_LOCK        1
  129. #define CRYPTO_UNLOCK        2
  130. #define CRYPTO_READ        4
  131. #define CRYPTO_WRITE        8
  132.  
  133. #ifndef NO_LOCKING
  134. #ifndef CRYPTO_w_lock
  135. #define CRYPTO_w_lock(type)    \
  136.     CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
  137. #define CRYPTO_w_unlock(type)    \
  138.     CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
  139. #define CRYPTO_r_lock(type)    \
  140.     CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__)
  141. #define CRYPTO_r_unlock(type)    \
  142.     CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__)
  143. #define CRYPTO_add(addr,amount,type)    \
  144.     CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__)
  145. #endif
  146. #else
  147. #define CRYPTO_w_lock(a)
  148. #define    CRYPTO_w_unlock(a)
  149. #define CRYPTO_r_lock(a)
  150. #define CRYPTO_r_unlock(a)
  151. #define CRYPTO_add(a,b,c)    ((*(a))+=(b))
  152. #endif
  153.  
  154. /* Some applications as well as some parts of OpenSSL need to allocate
  155.    and deallocate locks in a dynamic fashion.  The following typedef
  156.    makes this possible in a type-safe manner.  */
  157. /* struct CRYPTO_dynlock_value has to be defined by the application. */
  158. typedef struct
  159.     {
  160.     int references;
  161.     struct CRYPTO_dynlock_value *data;
  162.     } CRYPTO_dynlock;
  163.  
  164.  
  165. /* The following can be used to detect memory leaks in the SSLeay library.
  166.  * It used, it turns on malloc checking */
  167.  
  168. #define CRYPTO_MEM_CHECK_OFF    0x0    /* an enume */
  169. #define CRYPTO_MEM_CHECK_ON    0x1    /* a bit */
  170. #define CRYPTO_MEM_CHECK_ENABLE    0x2    /* a bit */
  171. #define CRYPTO_MEM_CHECK_DISABLE 0x3    /* an enume */
  172.  
  173. /* The following are bit values to turn on or off options connected to the
  174.  * malloc checking functionality */
  175.  
  176. /* Adds time to the memory checking information */
  177. #define V_CRYPTO_MDEBUG_TIME    0x1 /* a bit */
  178. /* Adds thread number to the memory checking information */
  179. #define V_CRYPTO_MDEBUG_THREAD    0x2 /* a bit */
  180.  
  181. #define V_CRYPTO_MDEBUG_ALL (V_CRYPTO_MDEBUG_TIME | V_CRYPTO_MDEBUG_THREAD)
  182.  
  183.  
  184. /* predec of the BIO type */
  185. typedef struct bio_st BIO_dummy;
  186.  
  187. typedef struct crypto_ex_data_st
  188.     {
  189.     STACK *sk;
  190.     int dummy; /* gcc is screwing up this data structure :-( */
  191.     } CRYPTO_EX_DATA;
  192.  
  193. /* Called when a new object is created */
  194. typedef int CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
  195.                     int idx, long argl, void *argp);
  196. /* Called when an object is free()ed */
  197. typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
  198.                     int idx, long argl, void *argp);
  199. /* Called when we need to dup an object */
  200. typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d, 
  201.                     int idx, long argl, void *argp);
  202.  
  203. /* This stuff is basically class callback functions
  204.  * The current classes are SSL_CTX, SSL, SSL_SESSION, and a few more */
  205.  
  206. typedef struct crypto_ex_data_func_st
  207.     {
  208.     long argl;    /* Arbitary long */
  209.     void *argp;    /* Arbitary void * */
  210.     CRYPTO_EX_new *new_func;
  211.     CRYPTO_EX_free *free_func;
  212.     CRYPTO_EX_dup *dup_func;
  213.     } CRYPTO_EX_DATA_FUNCS;
  214.  
  215. DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
  216.  
  217. /* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA
  218.  * entry.
  219.  */
  220.  
  221. #define CRYPTO_EX_INDEX_BIO        0
  222. #define CRYPTO_EX_INDEX_SSL        1
  223. #define CRYPTO_EX_INDEX_SSL_CTX        2
  224. #define CRYPTO_EX_INDEX_SSL_SESSION    3
  225. #define CRYPTO_EX_INDEX_X509_STORE    4
  226. #define CRYPTO_EX_INDEX_X509_STORE_CTX    5
  227.  
  228.  
  229. /* This is the default callbacks, but we can have others as well:
  230.  * this is needed in Win32 where the application malloc and the
  231.  * library malloc may not be the same.
  232.  */
  233. #define CRYPTO_malloc_init()    CRYPTO_set_mem_functions(\
  234.     malloc, realloc, free)
  235.  
  236. #if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD
  237. # ifndef CRYPTO_MDEBUG /* avoid duplicate #define */
  238. #  define CRYPTO_MDEBUG
  239. # endif
  240. #endif
  241.  
  242. /* Set standard debugging functions (not done by default
  243.  * unless CRYPTO_MDEBUG is defined) */
  244. #define CRYPTO_malloc_debug_init()    do {\
  245.     CRYPTO_set_mem_debug_functions(\
  246.         CRYPTO_dbg_malloc,\
  247.         CRYPTO_dbg_realloc,\
  248.         CRYPTO_dbg_free,\
  249.         CRYPTO_dbg_set_options,\
  250.         CRYPTO_dbg_get_options);\
  251.     } while(0)
  252.  
  253. int CRYPTO_mem_ctrl(int mode);
  254. int CRYPTO_is_mem_check_on(void);
  255.  
  256. /* for applications */
  257. #define MemCheck_start() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON)
  258. #define MemCheck_stop()    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF)
  259.  
  260. /* for library-internal use */
  261. #define MemCheck_on()    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE)
  262. #define MemCheck_off()    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE)
  263. #define is_MemCheck_on() CRYPTO_is_mem_check_on()
  264.  
  265. #define OPENSSL_malloc(num)    CRYPTO_malloc((int)num,__FILE__,__LINE__)
  266. #define OPENSSL_realloc(addr,num) \
  267.     CRYPTO_realloc((char *)addr,(int)num,__FILE__,__LINE__)
  268. #define OPENSSL_remalloc(addr,num) \
  269.     CRYPTO_remalloc((char **)addr,(int)num,__FILE__,__LINE__)
  270. #define OPENSSL_freeFunc    CRYPTO_free
  271. #define OPENSSL_free(addr)    CRYPTO_free(addr)
  272.  
  273. #define OPENSSL_malloc_locked(num) \
  274.     CRYPTO_malloc_locked((int)num,__FILE__,__LINE__)
  275. #define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr)
  276.  
  277.  
  278. const char *SSLeay_version(int type);
  279. unsigned long SSLeay(void);
  280.  
  281. int OPENSSL_issetugid(void);
  282.  
  283. int CRYPTO_get_ex_new_index(int idx, STACK_OF(CRYPTO_EX_DATA_FUNCS) **skp, long argl, void *argp,
  284.          CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
  285. int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
  286. void *CRYPTO_get_ex_data(CRYPTO_EX_DATA *ad,int idx);
  287. int CRYPTO_dup_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, CRYPTO_EX_DATA *to,
  288.          CRYPTO_EX_DATA *from);
  289. void CRYPTO_free_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad);
  290. void CRYPTO_new_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad);
  291.  
  292. int CRYPTO_get_new_lockid(char *name);
  293.  
  294. int CRYPTO_num_locks(void); /* return CRYPTO_NUM_LOCKS (shared libs!) */
  295. void CRYPTO_lock(int mode, int type,const char *file,int line);
  296. void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
  297.                           const char *file,int line));
  298. void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
  299.         int line);
  300. void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
  301.                           const char *file, int line));
  302. int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
  303.                       const char *file,int line);
  304. void CRYPTO_set_id_callback(unsigned long (*func)(void));
  305. unsigned long (*CRYPTO_get_id_callback(void))(void);
  306. unsigned long CRYPTO_thread_id(void);
  307. const char *CRYPTO_get_lock_name(int type);
  308. int CRYPTO_add_lock(int *pointer,int amount,int type, const char *file,
  309.             int line);
  310.  
  311. int CRYPTO_get_new_dynlockid(void);
  312. void CRYPTO_destroy_dynlockid(int i);
  313. struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i);
  314. void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*dyn_create_function)(const char *file, int line));
  315. void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line));
  316. void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)(struct CRYPTO_dynlock_value *l, const char *file, int line));
  317. struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))(const char *file,int line);
  318. void (*CRYPTO_get_dynlock_lock_callback(void))(int mode, struct CRYPTO_dynlock_value *l, const char *file,int line);
  319. void (*CRYPTO_get_dynlock_destroy_callback(void))(struct CRYPTO_dynlock_value *l, const char *file,int line);
  320.  
  321. /* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions --
  322.  * call the latter last if you need different functions */
  323. int CRYPTO_set_mem_functions(void *(*m)(size_t),void *(*r)(void *,size_t), void (*f)(void *));
  324. int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*free_func)(void *));
  325. int CRYPTO_set_mem_debug_functions(void (*m)(void *,int,const char *,int,int),
  326.                    void (*r)(void *,void *,int,const char *,int,int),
  327.                    void (*f)(void *,int),
  328.                    void (*so)(long),
  329.                    long (*go)(void));
  330. void CRYPTO_get_mem_functions(void *(**m)(size_t),void *(**r)(void *, size_t), void (**f)(void *));
  331. void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *));
  332. void CRYPTO_get_mem_debug_functions(void (**m)(void *,int,const char *,int,int),
  333.                     void (**r)(void *,void *,int,const char *,int,int),
  334.                     void (**f)(void *,int),
  335.                     void (**so)(long),
  336.                     long (**go)(void));
  337.  
  338. void *CRYPTO_malloc_locked(int num, const char *file, int line);
  339. void CRYPTO_free_locked(void *);
  340. void *CRYPTO_malloc(int num, const char *file, int line);
  341. void CRYPTO_free(void *);
  342. void *CRYPTO_realloc(void *addr,int num, const char *file, int line);
  343. void *CRYPTO_remalloc(void *addr,int num, const char *file, int line);
  344.  
  345. void CRYPTO_set_mem_debug_options(long bits);
  346. long CRYPTO_get_mem_debug_options(void);
  347.  
  348. #define CRYPTO_push_info(info) \
  349.         CRYPTO_push_info_(info, __FILE__, __LINE__);
  350. int CRYPTO_push_info_(const char *info, const char *file, int line);
  351. int CRYPTO_pop_info(void);
  352. int CRYPTO_remove_all_info(void);
  353.  
  354.  
  355. /* Default debugging functions (enabled by CRYPTO_malloc_debug_init() macro;
  356.  * used as default in CRYPTO_MDEBUG compilations): */
  357. /* The last argument has the following significance:
  358.  *
  359.  * 0:    called before the actual memory allocation has taken place
  360.  * 1:    called after the actual memory allocation has taken place
  361.  */
  362. void CRYPTO_dbg_malloc(void *addr,int num,const char *file,int line,int before_p);
  363. void CRYPTO_dbg_realloc(void *addr1,void *addr2,int num,const char *file,int line,int before_p);
  364. void CRYPTO_dbg_free(void *addr,int before_p);
  365. /* Tell the debugging code about options.  By default, the following values
  366.  * apply:
  367.  *
  368.  * 0:                           Clear all options.
  369.  * V_CRYPTO_MDEBUG_TIME (1):    Set the "Show Time" option.
  370.  * V_CRYPTO_MDEBUG_THREAD (2):  Set the "Show Thread Number" option.
  371.  * V_CRYPTO_MDEBUG_ALL (3):     1 + 2
  372.  */
  373. void CRYPTO_dbg_set_options(long bits);
  374. long CRYPTO_dbg_get_options(void);
  375.  
  376.  
  377. #ifndef NO_FP_API
  378. void CRYPTO_mem_leaks_fp(FILE *);
  379. #endif
  380. void CRYPTO_mem_leaks(struct bio_st *bio);
  381. /* unsigned long order, char *file, int line, int num_bytes, char *addr */
  382. void CRYPTO_mem_leaks_cb(void (*cb)(unsigned long, const char *, int, int, void *));
  383.  
  384. /* BEGIN ERROR CODES */
  385. /* The following lines are auto generated by the script mkerr.pl. Any changes
  386.  * made after this point may be overwritten when the script is next run.
  387.  */
  388. void ERR_load_CRYPTO_strings(void);
  389.  
  390. /* Error codes for the CRYPTO functions. */
  391.  
  392. /* Function codes. */
  393. #define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX         100
  394. #define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID         103
  395. #define CRYPTO_F_CRYPTO_GET_NEW_LOCKID             101
  396. #define CRYPTO_F_CRYPTO_SET_EX_DATA             102
  397.  
  398. /* Reason codes. */
  399. #define CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK         100
  400.  
  401. #ifdef  __cplusplus
  402. }
  403. #endif
  404. #endif
  405.